---
title: 语法对比与映射
description: 详细对比 Python 和 JavaScript 的语法差异，学习如何将 Python 的编程思维映射到 JavaScript 语法中，掌握变量、数据类型、控制流等核心概念。
---

# 语法对比与映射

作为 Python 开发者，你已经熟悉了优雅简洁的 Python 语法。本模块将帮助你系统地理解 JavaScript 语法，并学会如何将 Python 的编程思维有效地映射到 JavaScript 中。

## 变量声明和赋值

### Python vs JavaScript 变量声明

<PythonEditor title="变量声明对比" compare={true}>
```python !! py
# Python：简单的变量赋值
# 变量无需声明，直接赋值
name = "Alice"
age = 25
is_student = True
score = 95.5

# 动态类型，可以重新赋值为不同类型
name = 123
age = "二十五岁"

# 多重赋值
x, y, z = 1, 2, 3
a = b = c = 0

# 序列解包
numbers = [1, 2, 3, 4, 5]
first, second, *rest = numbers
print(f"第一个: {first}, 第二个: {second}, 其余: {rest}")

# 交换变量
x, y = y, x

# 全局变量和局部变量
global_var = "全局变量"

def example_function():
    local_var = "局部变量"
    global global_var
    global_var = "修改后的全局变量"
    return local_var
```

```javascript !! js
// JavaScript：需要使用关键字声明变量
// let：块级作用域，可重新赋值
let name = "Alice";
let age = 25;
let isStudent = true;
let score = 95.5;

// 可以重新赋值为不同类型
name = 123;
age = "二十五岁";

// const：块级作用域，不可重新赋值（但对象内容可变）
const PI = 3.14159;
const user = { name: "Bob", age: 30 };
// PI = 3.14; // 错误：不能重新赋值
user.age = 31; // 可以：对象内容可以修改

// var：函数作用域（不推荐使用）
var oldStyle = "旧式声明";

// 解构赋值
const numbers = [1, 2, 3, 4, 5];
const [first, second, ...rest] = numbers;
console.log(`第一个: ${first}, 第二个: ${second}, 其余: ${rest}`);

// 对象解构
const person = { name: "Charlie", age: 28, city: "Beijing" };
const { name: personName, age: personAge } = person;

// 交换变量（ES6+）
[x, y] = [y, x];

// 全局变量和局部变量
let globalVar = "全局变量";

function exampleFunction() {
    let localVar = "局部变量";
    globalVar = "修改后的全局变量";
    return localVar;
}
```
</PythonEditor>

## 数据类型对比

### 基本数据类型

<PythonEditor title="基本数据类型对比" compare={true}>
```python !! py
# Python 基本数据类型
# 1. 数字类型
integer_num = 42
float_num = 3.14159
complex_num = 3 + 4j

# 2. 字符串
single_quote = 'Hello'
double_quote = "World"
triple_quote = """
多行字符串
可以跨越多行
"""

# 字符串格式化
name = "Alice"
age = 25
formatted = f"我是 {name}，今年 {age} 岁"
old_format = "我是 {}，今年 {} 岁".format(name, age)

# 3. 布尔值
is_true = True
is_false = False

# 4. None 类型
nothing = None

# 类型检查
print(f"integer_num 的类型: {type(integer_num)}")
print(f"是否为整数: {isinstance(integer_num, int)}")

# 类型转换
str_number = "123"
converted = int(str_number)
back_to_str = str(converted)
```

```javascript !! js
// JavaScript 基本数据类型
// 1. 数字类型（只有 number 类型）
let integerNum = 42;
let floatNum = 3.14159;
// JavaScript 没有内置复数类型

// 特殊数字值
let infinity = Infinity;
let negInfinity = -Infinity;
let notANumber = NaN;

// 2. 字符串
let singleQuote = 'Hello';
let doubleQuote = "World";
let templateLiteral = `
多行字符串
可以跨越多行
`;

// 模板字符串（字符串插值）
const name = "Alice";
const age = 25;
const formatted = `我是 ${name}，今年 ${age} 岁`;

// 3. 布尔值
let isTrue = true;
let isFalse = false;

// 4. undefined 和 null
let notDefined = undefined;
let empty = null;

// 5. Symbol (ES6+)
let symbol = Symbol('description');

// 6. BigInt (ES2020+)
let bigNumber = 1234567890123456789012345678901234567890n;

// 类型检查
console.log(`integerNum 的类型: ${typeof integerNum}`);
console.log(`是否为数字: ${typeof integerNum === 'number'}`);

// 类型转换
let strNumber = "123";
let converted = parseInt(strNumber);
let backToStr = String(converted);
// 或者使用隐式转换
let implicitConversion = strNumber * 1;
```
</PythonEditor>

### 复合数据类型

<PythonEditor title="复合数据类型对比" compare={true}>
```python !! py
# Python 复合数据类型

# 1. 列表（可变，有序）
fruits = ["apple", "banana", "orange"]
fruits.append("grape")
fruits[0] = "pear"
print(f"水果列表: {fruits}")

# 列表方法
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()              # 原地排序
sorted_nums = sorted([5, 2, 8, 1])  # 返回新列表
numbers.reverse()           # 反转
popped = numbers.pop()      # 弹出最后一个元素

# 2. 元组（不可变，有序）
coordinates = (10, 20)
rgb = (255, 128, 0)
# coordinates[0] = 15  # 错误：元组不可变

# 3. 字典（键值对）
student = {
    "name": "Alice",
    "age": 20,
    "grades": [85, 92, 78]
}
student["email"] = "alice@example.com"  # 添加新键
name = student.get("name", "Unknown")   # 安全获取

# 字典方法
keys = student.keys()
values = student.values()
items = student.items()

# 4. 集合（无序，唯一）
unique_numbers = {1, 2, 3, 4, 5}
unique_numbers.add(6)
unique_numbers.discard(1)

# 集合操作
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
union = set1 | set2         # 并集
intersection = set1 & set2  # 交集
difference = set1 - set2    # 差集
```

```javascript !! js
// JavaScript 复合数据类型

// 1. 数组（类似 Python 列表）
let fruits = ["apple", "banana", "orange"];
fruits.push("grape");       // 添加到末尾
fruits[0] = "pear";         // 修改元素
console.log(`水果数组: ${fruits}`);

// 数组方法
let numbers = [3, 1, 4, 1, 5, 9, 2, 6];
numbers.sort();             // 原地排序（注意：默认按字符串排序）
numbers.sort((a, b) => a - b);  // 数字排序
let sortedNums = [5, 2, 8, 1].sort((a, b) => a - b);
numbers.reverse();          // 反转
let popped = numbers.pop(); // 弹出最后一个元素

// 函数式数组方法
let doubled = numbers.map(x => x * 2);
let evens = numbers.filter(x => x % 2 === 0);
let sum = numbers.reduce((acc, x) => acc + x, 0);

// 2. 对象（类似 Python 字典）
let student = {
    name: "Alice",
    age: 20,
    grades: [85, 92, 78]
};
student.email = "alice@example.com";  // 添加新属性
student["phone"] = "123-456-7890";    // 方括号语法
let name = student.name || "Unknown"; // 获取属性

// 对象方法
let keys = Object.keys(student);
let values = Object.values(student);
let entries = Object.entries(student);

// 3. Set（ES6+，类似 Python 集合）
let uniqueNumbers = new Set([1, 2, 3, 4, 5]);
uniqueNumbers.add(6);
uniqueNumbers.delete(1);

// Set 操作（需要手动实现）
let set1 = new Set([1, 2, 3, 4]);
let set2 = new Set([3, 4, 5, 6]);
let union = new Set([...set1, ...set2]);
let intersection = new Set([...set1].filter(x => set2.has(x)));
let difference = new Set([...set1].filter(x => !set2.has(x)));

// 4. Map（ES6+，更强大的键值对）
let userMap = new Map();
userMap.set("name", "Bob");
userMap.set("age", 30);
userMap.set(1, "数字键");

// 可以使用任何类型作为键
let objKey = {};
userMap.set(objKey, "对象作为键");
```
</PythonEditor>

## 控制流语句

### 条件语句

<PythonEditor title="条件语句对比" compare={true}>
```python !! py
# Python 条件语句

# 基本 if-elif-else
score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

print(f"成绩: {grade}")

# 条件表达式（三元运算符）
age = 20
status = "成年人" if age >= 18 else "未成年人"

# 真值测试
empty_list = []
if not empty_list:
    print("列表为空")

# 链式比较
x = 5
if 0 < x < 10:
    print("x 在 0 到 10 之间")

# in 运算符
fruits = ["apple", "banana", "orange"]
if "apple" in fruits:
    print("找到苹果")

# is 运算符（身份比较）
a = None
if a is None:
    print("a 是 None")

# 复合条件
username = "admin"
password = "123456"
if username == "admin" and password == "123456":
    print("登录成功")
elif username == "admin" or password == "admin":
    print("部分信息正确")
else:
    print("登录失败")
```

```javascript !! js
// JavaScript 条件语句

// 基本 if-else if-else
let score = 85;
let grade;

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else {
    grade = "F";
}

console.log(`成绩: ${grade}`);

// 条件运算符（三元运算符）
let age = 20;
let status = age >= 18 ? "成年人" : "未成年人";

// 逻辑运算符的短路特性
let emptyArray = [];
if (!emptyArray.length) {
    console.log("数组为空");
}

// 范围检查（需要分别比较）
let x = 5;
if (x > 0 && x < 10) {
    console.log("x 在 0 到 10 之间");
}

// 数组包含检查
let fruits = ["apple", "banana", "orange"];
if (fruits.includes("apple")) {
    console.log("找到苹果");
}

// 严格相等和类型检查
let a = null;
if (a === null) {
    console.log("a 是 null");
}

// undefined 检查
let b;
if (typeof b === 'undefined') {
    console.log("b 是 undefined");
}

// 复合条件
let username = "admin";
let password = "123456";
if (username === "admin" && password === "123456") {
    console.log("登录成功");
} else if (username === "admin" || password === "admin") {
    console.log("部分信息正确");
} else {
    console.log("登录失败");
}

// switch 语句（Python 没有，但 Python 3.10+ 有 match）
let day = 3;
let dayName;
switch (day) {
    case 1:
        dayName = "星期一";
        break;
    case 2:
        dayName = "星期二";
        break;
    case 3:
        dayName = "星期三";
        break;
    default:
        dayName = "未知";
}
```
</PythonEditor>

### 循环语句

<PythonEditor title="循环语句对比" compare={true}>
```python !! py
# Python 循环语句

# 1. for 循环（迭代）
# 遍历列表
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(f"水果: {fruit}")

# 带索引的遍历
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# 遍历字典
student = {"name": "Alice", "age": 20, "grade": "A"}
for key, value in student.items():
    print(f"{key}: {value}")

# 只遍历键或值
for key in student.keys():
    print(f"键: {key}")
for value in student.values():
    print(f"值: {value}")

# range() 函数
for i in range(5):          # 0 到 4
    print(f"数字: {i}")

for i in range(2, 8):       # 2 到 7
    print(f"范围: {i}")

for i in range(0, 10, 2):   # 0, 2, 4, 6, 8
    print(f"步长: {i}")

# 2. while 循环
count = 0
while count < 5:
    print(f"计数: {count}")
    count += 1

# 3. 循环控制
for i in range(10):
    if i == 3:
        continue    # 跳过当前迭代
    if i == 7:
        break       # 跳出循环
    print(f"循环: {i}")

# 4. else 子句（循环正常结束时执行）
for i in range(5):
    print(i)
else:
    print("循环正常结束")

# 5. 列表推导式
squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]
```

```javascript !! js
// JavaScript 循环语句

// 1. for...of 循环（ES6+，类似 Python 的 for）
let fruits = ["apple", "banana", "orange"];
for (let fruit of fruits) {
    console.log(`水果: ${fruit}`);
}

// 带索引的遍历（使用 entries()）
for (let [index, fruit] of fruits.entries()) {
    console.log(`${index}: ${fruit}`);
}

// 遍历对象（for...in）
let student = {name: "Alice", age: 20, grade: "A"};
for (let key in student) {
    console.log(`${key}: ${student[key]}`);
}

// 使用 Object.entries() 遍历对象
for (let [key, value] of Object.entries(student)) {
    console.log(`${key}: ${value}`);
}

// 只遍历键或值
for (let key of Object.keys(student)) {
    console.log(`键: ${key}`);
}
for (let value of Object.values(student)) {
    console.log(`值: ${value}`);
}

// 2. 传统 for 循环
for (let i = 0; i < 5; i++) {
    console.log(`数字: ${i}`);
}

for (let i = 2; i < 8; i++) {
    console.log(`范围: ${i}`);
}

for (let i = 0; i < 10; i += 2) {
    console.log(`步长: ${i}`);
}

// 3. while 循环
let count = 0;
while (count < 5) {
    console.log(`计数: ${count}`);
    count++;
}

// 4. do...while 循环（Python 没有）
let num = 0;
do {
    console.log(`至少执行一次: ${num}`);
    num++;
} while (num < 3);

// 5. 循环控制
for (let i = 0; i < 10; i++) {
    if (i === 3) {
        continue;   // 跳过当前迭代
    }
    if (i === 7) {
        break;      // 跳出循环
    }
    console.log(`循环: ${i}`);
}

// 6. 数组方法（类似列表推导式）
let squares = Array.from({length: 10}, (_, i) => i ** 2);
// 或者使用 map
let numbers = Array.from({length: 10}, (_, i) => i);
let squaresMapped = numbers.map(x => x ** 2);
let evenSquares = numbers.filter(x => x % 2 === 0).map(x => x ** 2);
```
</PythonEditor>

## 函数定义和调用

### 函数基础

<PythonEditor title="函数定义对比" compare={true}>
```python !! py
# Python 函数定义

# 1. 基本函数
def greet(name):
    """问候函数"""
    return f"Hello, {name}!"

# 调用函数
message = greet("Alice")
print(message)

# 2. 带默认参数的函数
def introduce(name, age, city="北京"):
    return f"我是 {name}，今年 {age} 岁，来自 {city}"

# 不同的调用方式
print(introduce("Bob", 25))
print(introduce("Charlie", 30, "上海"))
print(introduce(age=28, name="David"))  # 关键字参数

# 3. 可变参数
def sum_numbers(*args):
    """接收任意数量的参数"""
    total = 0
    for num in args:
        total += num
    return total

print(sum_numbers(1, 2, 3, 4, 5))

# 4. 关键字参数
def create_user(**kwargs):
    """接收任意关键字参数"""
    user = {}
    for key, value in kwargs.items():
        user[key] = value
    return user

user = create_user(name="Eve", age=22, email="eve@example.com")
print(user)

# 5. 混合参数
def complex_function(required, default="默认值", *args, **kwargs):
    print(f"必需参数: {required}")
    print(f"默认参数: {default}")
    print(f"可变参数: {args}")
    print(f"关键字参数: {kwargs}")

complex_function("必需", "自定义", 1, 2, 3, name="测试", age=30)

# 6. Lambda 函数
square = lambda x: x ** 2
add = lambda x, y: x + y

numbers = [1, 2, 3, 4, 5]
squared = list(map(square, numbers))
print(squared)

# 7. 类型注解（Python 3.5+）
def calculate_area(length: float, width: float) -> float:
    """计算矩形面积"""
    return length * width
```

```javascript !! js
// JavaScript 函数定义

// 1. 函数声明
function greet(name) {
    // 问候函数
    return `Hello, ${name}!`;
}

// 调用函数
let message = greet("Alice");
console.log(message);

// 2. 函数表达式
const introduce = function(name, age, city = "北京") {
    return `我是 ${name}，今年 ${age} 岁，来自 ${city}`;
};

// 不同的调用方式
console.log(introduce("Bob", 25));
console.log(introduce("Charlie", 30, "上海"));
// JavaScript 没有关键字参数，但可以用对象模拟
console.log(introduce("David", 28));

// 3. 箭头函数（ES6+）
const multiply = (x, y) => x * y;
const square = x => x ** 2;  // 单参数可省略括号
const sayHello = () => "Hello!";  // 无参数

// 4. 剩余参数（ES6+，类似 Python 的 *args）
function sumNumbers(...args) {
    // 接收任意数量的参数
    let total = 0;
    for (let num of args) {
        total += num;
    }
    return total;
}

console.log(sumNumbers(1, 2, 3, 4, 5));

// 5. 对象参数（模拟关键字参数）
function createUser({name, age, email}) {
    // 使用解构参数
    return {name, age, email};
}

let user = createUser({name: "Eve", age: 22, email: "eve@example.com"});
console.log(user);

// 也可以使用可选参数
function createUserOptional(options = {}) {
    const {name, age, email} = options;
    return {name, age, email};
}

// 6. 混合参数
function complexFunction(required, defaultParam = "默认值", ...args) {
    console.log(`必需参数: ${required}`);
    console.log(`默认参数: ${defaultParam}`);
    console.log(`剩余参数: ${args}`);
}

complexFunction("必需", "自定义", 1, 2, 3);

// 7. 高阶函数和回调
const numbers = [1, 2, 3, 4, 5];
const squared = numbers.map(x => x ** 2);
const evens = numbers.filter(x => x % 2 === 0);
const sum = numbers.reduce((acc, x) => acc + x, 0);

console.log(squared);

// 8. 立即执行函数表达式 (IIFE)
(function() {
    console.log("立即执行的函数");
})();

// 9. 函数提升（Hoisting）
console.log(hoistedFunction()); // 可以在定义前调用

function hoistedFunction() {
    return "函数声明会被提升";
}

// 10. 闭包
function createCounter() {
    let count = 0;
    return function() {
        count++;
        return count;
    };
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2
```
</PythonEditor>

## 运算符对比

### 算术和比较运算符

<PythonEditor title="运算符对比" compare={true}>
```python !! py
# Python 运算符

# 1. 算术运算符
a, b = 10, 3

print(f"加法: {a + b}")      # 13
print(f"减法: {a - b}")      # 7
print(f"乘法: {a * b}")      # 30
print(f"除法: {a / b}")      # 3.333...
print(f"整除: {a // b}")     # 3
print(f"取模: {a % b}")      # 1
print(f"幂运算: {a ** b}")   # 1000

# 2. 比较运算符
x, y = 5, 5
print(f"相等: {x == y}")     # True
print(f"不等: {x != y}")     # False
print(f"大于: {x > y}")      # False
print(f"小于: {x < y}")      # False
print(f"大于等于: {x >= y}") # True
print(f"小于等于: {x <= y}") # True

# 身份运算符
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print(f"list1 == list2: {list1 == list2}")  # True（值相等）
print(f"list1 is list2: {list1 is list2}")  # False（不是同一对象）
print(f"list1 is list3: {list1 is list3}")  # True（是同一对象）

# 3. 逻辑运算符
p, q = True, False
print(f"与: {p and q}")      # False
print(f"或: {p or q}")       # True
print(f"非: {not p}")        # False

# 4. 成员运算符
fruits = ["apple", "banana", "orange"]
print(f"'apple' in fruits: {'apple' in fruits}")        # True
print(f"'grape' not in fruits: {'grape' not in fruits}") # True

# 5. 位运算符
a, b = 12, 5  # 1100, 0101 in binary
print(f"按位与: {a & b}")    # 4 (0100)
print(f"按位或: {a | b}")    # 13 (1101)
print(f"按位异或: {a ^ b}")  # 9 (1001)
print(f"按位取反: {~a}")     # -13
print(f"左移: {a << 1}")     # 24
print(f"右移: {a >> 1}")     # 6

# 6. 赋值运算符
num = 10
num += 5    # num = num + 5
num *= 2    # num = num * 2
print(f"复合赋值后: {num}") # 30
```

```javascript !! js
// JavaScript 运算符

// 1. 算术运算符
let a = 10, b = 3;

console.log(`加法: ${a + b}`);      // 13
console.log(`减法: ${a - b}`);      // 7
console.log(`乘法: ${a * b}`);      // 30
console.log(`除法: ${a / b}`);      // 3.333...
console.log(`取模: ${a % b}`);      // 1
console.log(`幂运算: ${a ** b}`);   // 1000 (ES2016+)

// JavaScript 特有：++ 和 --
let count = 5;
console.log(`前置递增: ${++count}`); // 6
console.log(`后置递增: ${count++}`); // 6 (然后 count 变成 7)

// 2. 比较运算符
let x = 5, y = "5";
console.log(`相等（==）: ${x == y}`);    // true（会进行类型转换）
console.log(`严格相等（===）: ${x === y}`); // false（不进行类型转换）
console.log(`不等（!=）: ${x != y}`);    // false
console.log(`严格不等（!==）: ${x !== y}`); // true

console.log(`大于: ${x > 3}`);      // true
console.log(`小于: ${x < 10}`);     // true
console.log(`大于等于: ${x >= 5}`); // true
console.log(`小于等于: ${x <= 5}`); // true

// 对象比较
let obj1 = {a: 1};
let obj2 = {a: 1};
let obj3 = obj1;

console.log(`obj1 == obj2: ${obj1 == obj2}`);   // false（不同对象）
console.log(`obj1 === obj3: ${obj1 === obj3}`); // true（同一对象）

// 3. 逻辑运算符
let p = true, q = false;
console.log(`与（&&）: ${p && q}`);     // false
console.log(`或（||）: ${p || q}`);     // true
console.log(`非（!）: ${!p}`);          // false

// 短路求值
let name = null;
let displayName = name || "默认名称";   // "默认名称"
console.log(displayName);

// 空值合并（ES2020+）
let username = null;
let defaultUser = username ?? "游客";   // "游客"
console.log(defaultUser);

// 4. 包含检查
let fruits = ["apple", "banana", "orange"];
console.log(`fruits.includes('apple'): ${fruits.includes('apple')}`);        // true
console.log(`!fruits.includes('grape'): ${!fruits.includes('grape')}`);      // true

// 对象属性检查
let person = {name: "Alice", age: 25};
console.log(`'name' in person: ${'name' in person}`);           // true
console.log(`person.hasOwnProperty('age'): ${person.hasOwnProperty('age')}`); // true

// 5. 位运算符
a = 12; b = 5;  // 1100, 0101 in binary
console.log(`按位与（&）: ${a & b}`);     // 4 (0100)
console.log(`按位或（|）: ${a | b}`);     // 13 (1101)
console.log(`按位异或（^）: ${a ^ b}`);   // 9 (1001)
console.log(`按位取反（~）: ${~a}`);      // -13
console.log(`左移（<<）: ${a << 1}`);     // 24
console.log(`右移（>>）: ${a >> 1}`);     // 6
console.log(`无符号右移（>>>）: ${a >>> 1}`); // 6

// 6. 赋值运算符
let num = 10;
num += 5;    // num = num + 5
num *= 2;    // num = num * 2
console.log(`复合赋值后: ${num}`); // 30

// 解构赋值（ES6+）
let [first, second] = [1, 2];
let {name: userName} = {name: "Bob"};
```
</PythonEditor>

## 字符串操作对比

<PythonEditor title="字符串操作对比" compare={true}>
```python !! py
# Python 字符串操作

text = "Hello, World!"
name = "Alice"
age = 25

# 1. 字符串格式化
# f-string（推荐）
formatted1 = f"我是 {name}，今年 {age} 岁"
# format 方法
formatted2 = "我是 {}，今年 {} 岁".format(name, age)
# 旧式格式化
formatted3 = "我是 %s，今年 %d 岁" % (name, age)

print(formatted1)

# 2. 字符串方法
print(f"长度: {len(text)}")
print(f"大写: {text.upper()}")
print(f"小写: {text.lower()}")
print(f"首字母大写: {text.capitalize()}")
print(f"标题格式: {text.title()}")

# 查找和替换
print(f"查找 'World': {text.find('World')}")  # 返回索引，找不到返回 -1
print(f"替换: {text.replace('World', 'Python')}")

# 分割和连接
words = text.split(', ')
print(f"分割: {words}")
joined = ' | '.join(words)
print(f"连接: {joined}")

# 去除空白
padded = "  Hello  "
print(f"去除空白: '{padded.strip()}'")
print(f"去除左空白: '{padded.lstrip()}'")
print(f"去除右空白: '{padded.rstrip()}'")

# 检查字符串
email = "user@example.com"
print(f"以 'user' 开头: {email.startswith('user')}")
print(f"以 '.com' 结尾: {email.endswith('.com')}")
print(f"是否为数字: {'123'.isdigit()}")
print(f"是否为字母: {'abc'.isalpha()}")

# 字符串切片
s = "Python Programming"
print(f"前6个字符: {s[:6]}")
print(f"后11个字符: {s[-11:]}")
print(f"每隔2个字符: {s[::2]}")
print(f"反转字符串: {s[::-1]}")

# 多行字符串
multiline = """
这是一个
多行字符串
示例
""".strip()
print(multiline)
```

```javascript !! js
// JavaScript 字符串操作

let text = "Hello, World!";
let name = "Alice";
let age = 25;

// 1. 字符串格式化
// 模板字符串（推荐）
let formatted1 = `我是 ${name}，今年 ${age} 岁`;
// 字符串拼接
let formatted2 = "我是 " + name + "，今年 " + age + " 岁";

console.log(formatted1);

// 2. 字符串属性和方法
console.log(`长度: ${text.length}`);
console.log(`大写: ${text.toUpperCase()}`);
console.log(`小写: ${text.toLowerCase()}`);

// 查找和替换
console.log(`查找 'World': ${text.indexOf('World')}`);  // 返回索引，找不到返回 -1
console.log(`包含 'World': ${text.includes('World')}`); // ES6+，返回布尔值
console.log(`替换: ${text.replace('World', 'JavaScript')}`);
console.log(`全部替换: ${text.replaceAll('l', 'L')}`);   // ES2021+

// 分割和连接
let words = text.split(', ');
console.log(`分割: ${words}`);
let joined = words.join(' | ');
console.log(`连接: ${joined}`);

// 去除空白
let padded = "  Hello  ";
console.log(`去除空白: '${padded.trim()}'`);
console.log(`去除左空白: '${padded.trimStart()}'`);     // ES2019+
console.log(`去除右空白: '${padded.trimEnd()}'`);       // ES2019+

// 检查字符串
let email = "user@example.com";
console.log(`以 'user' 开头: ${email.startsWith('user')}`);
console.log(`以 '.com' 结尾: ${email.endsWith('.com')}`);

// 字符串切片（使用 substring 或 slice）
let s = "JavaScript Programming";
console.log(`前10个字符: ${s.substring(0, 10)}`);
console.log(`后11个字符: ${s.slice(-11)}`);
console.log(`从索引4开始: ${s.substring(4)}`);

// 字符访问
console.log(`第一个字符: ${s[0]}`);
console.log(`最后一个字符: ${s[s.length - 1]}`);

// 字符串重复（ES6+）
console.log(`重复3次: ${'Ha'.repeat(3)}`);  // "HaHaHa"

// 填充字符串（ES2017+）
console.log(`左填充: ${'5'.padStart(3, '0')}`);    // "005"
console.log(`右填充: ${'5'.padEnd(3, '0')}`);      // "500"

// 多行字符串
let multiline = `
这是一个
多行字符串
示例
`.trim();
console.log(multiline);

// 字符串转数组
let chars = s.split('');
console.log(`字符数组: ${chars.slice(0, 5)}`);

// 反转字符串（JavaScript 需要转换为数组）
let reversed = s.split('').reverse().join('');
console.log(`反转字符串: ${reversed}`);
```
</PythonEditor>

## 异常处理对比

<PythonEditor title="异常处理对比" compare={true}>
```python !! py
# Python 异常处理

# 1. 基本 try-except
try:
    number = int(input("请输入一个数字: "))
    result = 10 / number
    print(f"结果: {result}")
except ValueError:
    print("输入的不是有效数字")
except ZeroDivisionError:
    print("不能除以零")
except Exception as e:
    print(f"其他错误: {e}")

# 2. try-except-else-finally
try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("文件未找到")
except PermissionError:
    print("没有读取权限")
else:
    print("文件读取成功")
    print(content)
finally:
    # 无论是否发生异常都会执行
    if 'file' in locals() and not file.closed:
        file.close()
        print("文件已关闭")

# 3. 抛出异常
def validate_age(age):
    if age < 0:
        raise ValueError("年龄不能为负数")
    if age > 150:
        raise ValueError("年龄不能超过150岁")
    return True

try:
    validate_age(-5)
except ValueError as e:
    print(f"验证错误: {e}")

# 4. 自定义异常
class CustomError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

def risky_operation():
    raise CustomError("这是一个自定义错误")

try:
    risky_operation()
except CustomError as e:
    print(f"捕获自定义异常: {e.message}")

# 5. 断言
def divide(a, b):
    assert b != 0, "除数不能为零"
    return a / b

try:
    result = divide(10, 0)
except AssertionError as e:
    print(f"断言错误: {e}")
```

```javascript !! js
// JavaScript 异常处理

// 1. 基本 try-catch
try {
    let input = prompt("请输入一个数字:");
    let number = parseInt(input);
    
    if (isNaN(number)) {
        throw new Error("输入的不是有效数字");
    }
    
    if (number === 0) {
        throw new Error("不能除以零");
    }
    
    let result = 10 / number;
    console.log(`结果: ${result}`);
} catch (error) {
    console.log(`错误: ${error.message}`);
}

// 2. try-catch-finally
try {
    // 模拟文件操作
    let fileExists = false;
    if (!fileExists) {
        throw new Error("文件未找到");
    }
    console.log("文件读取成功");
} catch (error) {
    if (error.message === "文件未找到") {
        console.log("文件未找到");
    } else {
        console.log(`其他错误: ${error.message}`);
    }
} finally {
    // 无论是否发生异常都会执行
    console.log("清理操作完成");
}

// 3. 抛出异常
function validateAge(age) {
    if (age < 0) {
        throw new Error("年龄不能为负数");
    }
    if (age > 150) {
        throw new Error("年龄不能超过150岁");
    }
    return true;
}

try {
    validateAge(-5);
} catch (error) {
    console.log(`验证错误: ${error.message}`);
}

// 4. 自定义错误类
class CustomError extends Error {
    constructor(message) {
        super(message);
        this.name = "CustomError";
    }
}

function riskyOperation() {
    throw new CustomError("这是一个自定义错误");
}

try {
    riskyOperation();
} catch (error) {
    if (error instanceof CustomError) {
        console.log(`捕获自定义异常: ${error.message}`);
    } else {
        console.log(`其他错误: ${error.message}`);
    }
}

// 5. 不同类型的错误
try {
    // TypeError
    let obj = null;
    obj.property = "value";
} catch (error) {
    if (error instanceof TypeError) {
        console.log("类型错误");
    }
}

try {
    // ReferenceError
    console.log(undefinedVariable);
} catch (error) {
    if (error instanceof ReferenceError) {
        console.log("引用错误");
    }
}

try {
    // SyntaxError（通常在解析时就会抛出）
    eval("invalid syntax here !");
} catch (error) {
    if (error instanceof SyntaxError) {
        console.log("语法错误");
    }
}

// 6. 断言功能（自实现）
function assert(condition, message) {
    if (!condition) {
        throw new Error(`Assertion failed: ${message}`);
    }
}

function divide(a, b) {
    assert(b !== 0, "除数不能为零");
    return a / b;
}

try {
    let result = divide(10, 0);
} catch (error) {
    console.log(`断言错误: ${error.message}`);
}

// 7. Promise 错误处理
async function asyncExample() {
    try {
        let response = await fetch('https://api.example.com/data');
        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }
        let data = await response.json();
        return data;
    } catch (error) {
        console.log(`异步操作错误: ${error.message}`);
        throw error; // 重新抛出错误
    }
}
```
</PythonEditor>

## 小结

本模块详细对比了 Python 和 JavaScript 的语法差异：

### 主要差异总结

1. **变量声明**：JavaScript 需要使用 `let`、`const`、`var` 关键字
2. **代码块**：JavaScript 使用大括号 `{}` 而不是缩进
3. **数据类型**：JavaScript 的类型系统更加宽松，有隐式类型转换
4. **字符串**：JavaScript 支持模板字符串，Python 有更多字符串方法
5. **函数**：JavaScript 有多种函数定义方式，支持箭头函数
6. **循环**：JavaScript 有 `for...of`、`for...in` 等多种循环方式
7. **异常处理**：基本概念相似，但语法略有不同

### 学习建议

1. **熟悉语法差异**：重点理解大括号、分号、变量声明的使用
2. **类型转换**：注意 JavaScript 的隐式类型转换规则
3. **函数特性**：掌握箭头函数、回调函数等 JavaScript 特有概念
4. **数组方法**：学习 `map`、`filter`、`reduce` 等函数式编程方法
5. **异步思维**：为后续学习异步编程做准备

下一个模块我们将深入学习 JavaScript 的动态类型系统，理解其与 Python 的微妙差异。

---

准备好深入了解 JavaScript 的类型系统了吗？让我们继续下一个模块的学习！
